package Linked_List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author : niu niu
 * @version : 1.0.0
 * @date : 2022/10/11 21:50
 * 不创建对象，当成 静态方法的集合
 */
public class 演示链表操作但是不代表链表 {
    public static void main(String[] args) {
//        遍历一条链表(手动创建链表());
//        遍历一条链表(null);
//        System.out.println(统计链表元素个数(手动创建链表()));

//        查找链表中左右的和某个元素相等的结点(手动创建链表(),100);
//        System.out.println(找到链表中的第n个结点(手动创建链表() , 3).val);
        Node head = null;
        head = 头插元素(head, 1000);
        head = 头插元素(head, 2000);
        head = 头插元素(head, 3000);


    }


    //创建链表
    //int [] -> Node head
    public static Node 根据数组创建链表() {
        //TODO
        return null;
    }

    public static Node 手动创建链表() {
        Node n1 = new Node(100);
        Node n2 = new Node(200);
        Node n3 = new Node(300);
        Node n4 = new Node(400);

        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = null;
        return n1;
    }

    //遍历
    public static void 遍历一条链表(Node head) {
        //cur 指向 head
        Node cur = head;
        while (cur != null) {//问 cur 如果还指向对象，返回true
            int element = cur.val;
            System.out.println(element);
            //cur 指向 cur.next（cur目前指向的对象的next引用） 指向的对象
            cur = cur.next;
        }
    }

    public static int 统计链表元素个数(Node head) {
        int count = 0;
        for (Node cur = head; cur != null; cur = cur.next) {
            count++;
        }
        return count;
    }

    private static Node 查找链表中某个元素所在的结点(Node head, int target) {
        Node cur = head;
        while (cur != null) {
            if (target == cur.val) {
                return cur;
            }
            cur = cur.next;
        }
        //没找到
        return null;
    }

    private static List<Node> 查找链表中左右的和某个元素相等的结点(Node head, int target) {
        List<Node> ans = new ArrayList<>();
        Node cur = head;
        while (cur != null) {
            if (target == cur.val) {
                ans.add(cur);
            }
            cur = cur.next;
        }
        //没找到
        return ans;
    }

    private static Node 找到链表中的第n个结点(Node head, int n) {

        Node cur = head;
        for (int i = 0; i < n - 1 && cur != null; i++) {
            cur = cur.next;
        }
        return cur;
    }

    // 链表中至少有 1 个结点
    private static Node 找到链表的倒数第1个结点(Node head) {
        Node cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }

        return cur;
    }

    private static Node 找链表的倒数第n个结点(Node head, int n) {
        Node cur = head;
        for (int i = 0; i < 统计链表元素个数(head) - n + 1 && cur != null; i++) {
            cur = cur.next;
        }
        return cur;
    }

    //需要返回Node引用，需要返回新的头结点，这样调用方法的人可以拿到最新的头结点
    private static Node 头插元素(Node head, int e) {
        //1. 把元素装入结点
        Node node = new Node(e);
//        if(head==null){// 链表是空的，则node 就是头节点
//            node.next = null;
//            return node;
//        }else{//不为空
//            node.next = head;
//            return node;
//        }
        node.next = head;
        return node;
    }

    private static Node 头插元素(Node head, Node node) {
        node.next = head;
        return node;
    }

    private static Node 头删元素(Node head) {
        if (head == null) {
            throw new RuntimeException("链表空");
        }
        return head.next;
    }
}
